Odesílání dat protokolu do služby Azure Monitor pomocí rozhraní API kolektoru dat HTTP (zastaralé)

V tomto článku se dozvíte, jak pomocí rozhraní API kolektoru dat HTTP odesílat data protokolů do služby Azure Monitor z klienta REST API. Popisuje, jak formátovat data shromážděná vaším skriptem nebo aplikací, zahrnout je do požadavku a nechat ji autorizovat službou Azure Monitor. Poskytujeme příklady pro Azure PowerShell, C# a Python.

Poznámka:

Rozhraní API kolektoru dat HTTP služby Azure Monitor je zastaralé a od 14. 9. 2026 už nebude funkční. Nahradilo ho rozhraní API pro příjem protokolů.

Koncepty

Rozhraní API kolektoru dat HTTP můžete použít k odesílání dat protokolu do pracovního prostoru služby Log Analytics ve službě Azure Monitor z libovolného klienta, který může volat rozhraní REST API. Klientem může být runbook ve službě Azure Automation, který shromažďuje data správy z Azure nebo jiného cloudu, nebo se může jednat o alternativní systém pro správu, který ke konsolidaci a analýze dat protokolů používá Azure Monitor.

Všechna data v pracovním prostoru služby Log Analytics se ukládají jako záznam s konkrétním typem záznamu. Data naformátujete tak, aby se odesílala do rozhraní API kolektoru dat HTTP jako více záznamů ve formátu JSON (JavaScript Object Notation). Při odesílání dat se v úložišti vytvoří jednotlivý záznam pro každý záznam v datové části požadavku.

Vytvořit žádost

Pokud chcete použít rozhraní API kolektoru dat HTTP, vytvoříte požadavek POST, který obsahuje data, která se mají odeslat ve formátu JSON. Následující tři tabulky uvádějí atributy, které jsou požadovány pro každý požadavek. Jednotlivé atributy podrobněji popíšeme dále v článku.

Identifikátor URI žádosti

Atribut	Vlastnost
metoda	POST
Identifikátor URI	<https:// CustomerId.ods.opinsights.azure.com/api/logs?api-version=2016-04-01>
Typ obsahu	application/json

Parametry identifikátoru URI požadavku

Parametr	Popis
CustomerID	Jedinečný identifikátor pracovního prostoru služby Log Analytics.
Prostředek	Název prostředku rozhraní API: /api/logs.
Verze rozhraní API	Verze rozhraní API, která se má použít s tímto požadavkem. V současné době je verze 2016-04-01.

Záhlaví žádosti

Hlavička	Popis
Autorizace	Podpis autorizace. Později v článku si můžete přečíst, jak vytvořit hlavičku HMAC-SHA256.
Typ protokolu	Zadejte typ záznamu odesílaných dat. Může obsahovat pouze písmena, číslice a podtržítko (_) a nesmí překročit 100 znaků.
x-ms-date	Datum zpracování požadavku ve formátu RFC 1123 .
x-ms-AzureResourceId	ID prostředku Azure, ke kterému by měla být data přidružená. Naplní vlastnost _ResourceId a umožní zahrnutí dat do dotazů kontextu prostředků. Pokud toto pole není zadané, nebudou data zahrnuta do dotazů kontextu prostředků.
pole vygenerované časem	Název pole v datech, která obsahuje časové razítko položky dat. Pokud zadáte pole, použije se jeho obsah pro TimeGenerated. Pokud toto pole nezadáte, výchozí hodnota pro TimeGenerated je čas, kdy se zpráva ingestuje. Obsah pole zprávy by měl odpovídat formátu ISO 8601 RRRR-MM-DDThh:mm:ssZ. Hodnota Generovaná časem nemůže být starší než 2 dny před přijetím času nebo více než den v budoucnu. V takovém případě se použije čas, kdy se zpráva ingestuje.

Autorizace

Každý požadavek na rozhraní API kolektoru dat HTTP služby Azure Monitor musí obsahovat autorizační hlavičku. Pokud chcete žádost ověřit, podepište požadavek buď primárním, nebo sekundárním klíčem pracovního prostoru, který požadavek vytváří. Pak tento podpis předejte jako součást požadavku.

Tady je formát autorizační hlavičky:

Authorization: SharedKey <WorkspaceID>:<Signature>

ID pracovního prostoru je jedinečný identifikátor pracovního prostoru služby Log Analytics. Podpis je kód HMAC (Hash-based Message Authentication Code), který je vytvořený z požadavku a pak vypočítá pomocí algoritmu SHA256. Pak ho zakódujete pomocí kódování Base64.

Tento formát použijte ke kódování řetězce podpisu SharedKey :

StringToSign = VERB + "\n" +
                  Content-Length + "\n" +
                  Content-Type + "\n" +
                  "x-ms-date:" + x-ms-date + "\n" +
                  "/api/logs";

Tady je příklad řetězce podpisu:

POST\n1024\napplication/json\nx-ms-date:Mon, 04 Apr 2016 08:00:00 GMT\n/api/logs

Pokud máte řetězec podpisu, zakódujte ho pomocí algoritmu HMAC-SHA256 v řetězci s kódováním UTF-8 a potom výsledek zakódujte jako Base64. Použijte tento formát:

Signature=Base64(HMAC-SHA256(UTF8(StringToSign)))

Ukázky v dalších částech obsahují vzorový kód, který vám pomůže vytvořit autorizační hlavičku.

Text požadavku

Text zprávy musí být ve formátu JSON. Musí obsahovat jeden nebo více záznamů s páry názvu vlastnosti a hodnoty v následujícím formátu. Název vlastnosti může obsahovat pouze písmena, číslice a znak podtržítka (_).

[
    {
        "property 1": "value1",
        "property 2": "value2",
        "property 3": "value3",
        "property 4": "value4"
    }
]

V jednom požadavku můžete dosáčet více záznamů pomocí následujícího formátu. Všechny záznamy musí být stejného typu záznamu.

[
    {
        "property 1": "value1",
        "property 2": "value2",
        "property 3": "value3",
        "property 4": "value4"
    },
    {
        "property 1": "value1",
        "property 2": "value2",
        "property 3": "value3",
        "property 4": "value4"
    }
]

Typ a vlastnosti záznamu

Při odesílání dat prostřednictvím rozhraní API kolektoru dat HTTP služby Azure Monitor definujete vlastní typ záznamu. V současné době nemůžete zapisovat data do existujících typů záznamů, které byly vytvořeny jinými datovými typy a řešeními. Azure Monitor přečte příchozí data a pak vytvoří vlastnosti, které odpovídají datovým typům zadaných hodnot.

Každý požadavek na rozhraní API kolektoru dat musí obsahovat hlavičku typu protokolu s názvem pro typ záznamu. Přípona _CL se automaticky připojí k zadanému názvu, aby se odlišila od jiných typů protokolů jako vlastní protokol. Pokud například zadáte název MyNewRecordType, Azure Monitor vytvoří záznam s typem MyNewRecordType_CL. To pomáhá zajistit, aby nedošlo ke konfliktům mezi uživatelsky vytvořenými názvy typů a názvy dodaných v aktuálních nebo budoucích řešeních Společnosti Microsoft.

K identifikaci datového typu vlastnosti přidá Azure Monitor k názvu vlastnosti příponu. Pokud vlastnost obsahuje hodnotu null, vlastnost není zahrnuta v tomto záznamu. Tato tabulka uvádí datový typ vlastnosti a odpovídající příponu:

Datový typ vlastnosti	Přípona
String	_s
Logická hodnota	_b
Hodnota s dvojitou přesností	_d
Datum/čas	_t
GUID (uložený jako řetězec)	_g

Poznámka:

Řetězcové hodnoty, které se jeví jako identifikátory GUID, mají příponu _g a formátují se jako identifikátor GUID, i když příchozí hodnota neobsahuje pomlčky. Příklad: "8145d822-13a7-44ad-859c-36f31a84f6dd" a "8145d82213a744ad859c36f31a84f6dd" jsou uloženy jako "8145d822-13a7-44ad-859c-36f31a84f6dd". Jedinými rozdíly mezi tímto a jiným řetězcem jsou _g v názvu a vložení pomlček, pokud nejsou zadané ve vstupu.

Datový typ, který Azure Monitor používá pro každou vlastnost, závisí na tom, jestli typ záznamu pro nový záznam již existuje.

• Pokud typ záznamu neexistuje, Azure Monitor vytvoří nový pomocí odvození typu JSON k určení datového typu pro každou vlastnost nového záznamu.
• Pokud typ záznamu existuje, Azure Monitor se pokusí vytvořit nový záznam na základě existujících vlastností. Pokud se datový typ vlastnosti v novém záznamu neshoduje a nedá se převést na existující typ nebo pokud záznam obsahuje vlastnost, která neexistuje, Azure Monitor vytvoří novou vlastnost s příslušnou příponou.

Například následující položka pro odeslání vytvoří záznam se třemi vlastnostmi, number_d, boolean_b a string_s:

Pokud byste chtěli odeslat tuto další položku se všemi hodnotami formátovanými jako řetězce, vlastnosti se nezměnily. Hodnoty můžete převést na existující datové typy.

Pokud ale provedete toto další odeslání, Azure Monitor vytvoří nové vlastnosti boolean_d a string_d. Tyto hodnoty nelze převést.

Pokud pak před vytvořením typu záznamu odešlete následující položku, azure Monitor vytvoří záznam se třemi vlastnostmi, number_s, boolean_s a string_s. V této položce je každá z počátečních hodnot formátována jako řetězec:

Rezervované vlastnosti

Následující vlastnosti jsou rezervované a neměly by se používat ve vlastním typu záznamu. Pokud datová část obsahuje některý z těchto názvů vlastností, zobrazí se chyba:

• klient
• TimeGenerated
• RawData

Omezení dat

Data odesílaná do rozhraní API pro shromažďování dat služby Azure Monitor podléhají určitým omezením:

• Maximálně 30 MB na příspěvek do rozhraní API kolektoru dat služby Azure Monitor. Toto je limit velikosti pro jeden příspěvek. Pokud data z jednoho příspěvku překročí 30 MB, měli byste je rozdělit do bloků s menší velikostí a současně je odeslat.
• Maximálně 32 kB pro hodnoty polí. Pokud je hodnota pole větší než 32 kB, data se oříznou.
• Doporučeno maximálně 50 polí pro daný typ. Tento limit je praktický z hlediska použitelnosti a vyhledávání.
• Tabulky v pracovních prostorech služby Log Analytics podporují pouze 500 sloupců (označovaných jako pole v tomto článku).
• Maximálně 45 znaků pro názvy sloupců.

Návratové kódy

Stavový kód HTTP 200 znamená, že požadavek byl přijat ke zpracování. To znamená, že operace byla úspěšně dokončena.

Kompletní sada stavových kódů, které může služba vrátit, je uvedená v následující tabulce:

Kód	Stav	Kód chyby	Popis
200	OK		Požadavek byl úspěšně přijat.
400	Chybný požadavek	InactiveCustomer	Pracovní prostor byl zavřený.
400	Chybný požadavek	InvalidApiVersion	Zadaná verze rozhraní API nebyla službou rozpoznána.
400	Chybný požadavek	InvalidCustomerId	Zadané ID pracovního prostoru je neplatné.
400	Chybný požadavek	InvalidDataFormat	Byl odeslán neplatný kód JSON. Tělo odpovědi může obsahovat další informace o tom, jak chybu vyřešit.
400	Chybný požadavek	InvalidLogType	Zadaný typ protokolu obsahoval speciální znaky nebo číslice.
400	Chybný požadavek	MissingApiVersion	Verze rozhraní API nebyla zadána.
400	Chybný požadavek	MissingContentType	Typ obsahu nebyl zadán.
400	Chybný požadavek	MissingLogType	Nebyl zadán požadovaný typ protokolu hodnot.
400	Chybný požadavek	Nepodporovaný typContentType	Typ obsahu nebyl nastaven na application/json.
403	Zakázáno	InvalidAuthorization	Službě se nepodařilo ověřit požadavek. Ověřte, že ID pracovního prostoru a klíč připojení jsou platné.
404	Nenalezeno		Zadaná adresa URL je nesprávná nebo je požadavek příliš velký.
429	Příliš mnoho požadavků		U služby dochází k velkému objemu dat z vašeho účtu. Zkuste žádost zopakovat později.
500	Vnitřní chyba serveru	Nezadaná chyba	Služba zjistila vnitřní chybu. Zkuste žádost zopakovat.
503	Nedostupná služba	ServiceUnavailable	Služba momentálně není k dispozici pro příjem požadavků. Zkuste prosím žádost zopakovat.

Zadávání dotazů na data

Pokud chcete dotazovat data odesílaná rozhraním API kolektoru dat SLUŽBY Azure Monitor, vyhledejte záznamy, jejichž typ je roven hodnotě LogType , kterou jste zadali a připojili pomocí _CL. Pokud jste například použili MyCustomLog, vrátili byste všechny záznamy s MyCustomLog_CL.

Ukázkové požadavky

V této části jsou ukázky, které ukazují, jak odesílat data do rozhraní API kolektoru dat HTTP služby Azure Monitor pomocí různých programovacích jazyků.

Pro každou ukázku nastavte proměnné pro autorizační hlavičku následujícím způsobem:

1. Na webu Azure Portal vyhledejte pracovní prostor služby Log Analytics.
2. Vyberte agenty.
3. Napravo od ID pracovního prostoru vyberte ikonu Kopírovat a pak id vložte jako hodnotu proměnné ID zákazníka.
4. Napravo od primárního klíče vyberte ikonu Kopírovat a pak jako hodnotu proměnné sdíleného klíče vložte ID.

Případně můžete změnit proměnné pro typ protokolu a data JSON.

PowerShell

# Replace with your Workspace ID
$CustomerId = "xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx"  

# Replace with your Primary Key
$SharedKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# Specify the name of the record type that you'll be creating
$LogType = "MyRecordType"

# Optional name of a field that includes the timestamp for the data. If the time field is not specified, Azure Monitor assumes the time is the message ingestion time
$TimeStampField = ""


# Create two records with the same set of properties to create
$json = @"
[{  "StringValue": "MyString1",
    "NumberValue": 42,
    "BooleanValue": true,
    "DateValue": "2019-09-12T20:00:00.625Z",
    "GUIDValue": "9909ED01-A74C-4874-8ABF-D2678E3AE23D"
},
{   "StringValue": "MyString2",
    "NumberValue": 43,
    "BooleanValue": false,
    "DateValue": "2019-09-12T20:00:00.625Z",
    "GUIDValue": "8809ED01-A74C-4874-8ABF-D2678E3AE23D"
}]
"@

# Create the function to create the authorization signature
Function Build-Signature ($customerId, $sharedKey, $date, $contentLength, $method, $contentType, $resource)
{
    $xHeaders = "x-ms-date:" + $date
    $stringToHash = $method + "`n" + $contentLength + "`n" + $contentType + "`n" + $xHeaders + "`n" + $resource

    $bytesToHash = [Text.Encoding]::UTF8.GetBytes($stringToHash)
    $keyBytes = [Convert]::FromBase64String($sharedKey)

    $sha256 = New-Object System.Security.Cryptography.HMACSHA256
    $sha256.Key = $keyBytes
    $calculatedHash = $sha256.ComputeHash($bytesToHash)
    $encodedHash = [Convert]::ToBase64String($calculatedHash)
    $authorization = 'SharedKey {0}:{1}' -f $customerId,$encodedHash
    return $authorization
}

# Create the function to create and post the request
Function Post-LogAnalyticsData($customerId, $sharedKey, $body, $logType)
{
    $method = "POST"
    $contentType = "application/json"
    $resource = "/api/logs"
    $rfc1123date = [DateTime]::UtcNow.ToString("r")
    $contentLength = $body.Length
    $signature = Build-Signature `
        -customerId $customerId `
        -sharedKey $sharedKey `
        -date $rfc1123date `
        -contentLength $contentLength `
        -method $method `
        -contentType $contentType `
        -resource $resource
    $uri = "https://" + $customerId + ".ods.opinsights.azure.com" + $resource + "?api-version=2016-04-01"

    $headers = @{
        "Authorization" = $signature;
        "Log-Type" = $logType;
        "x-ms-date" = $rfc1123date;
        "time-generated-field" = $TimeStampField;
    }

    $response = Invoke-WebRequest -Uri $uri -Method $method -ContentType $contentType -Headers $headers -Body $body -UseBasicParsing
    return $response.StatusCode

}

# Submit the data to the API endpoint
Post-LogAnalyticsData -customerId $customerId -sharedKey $sharedKey -body ([System.Text.Encoding]::UTF8.GetBytes($json)) -logType $logType  

C#

using System;
using System.Net;
using System.Net.Http;
using System.Net.Http.Headers;
using System.Security.Cryptography;
using System.Text;
using System.Threading.Tasks;

namespace OIAPIExample
{
	class ApiExample
	{
		// An example JSON object, with key/value pairs
		static string json = @"[{""DemoField1"":""DemoValue1"",""DemoField2"":""DemoValue2""},{""DemoField3"":""DemoValue3"",""DemoField4"":""DemoValue4""}]";

		// Update customerId to your Log Analytics workspace ID
		static string customerId = "xxxxxxxx-xxx-xxx-xxx-xxxxxxxxxxxx";

		// For sharedKey, use either the primary or the secondary Connected Sources client authentication key   
		static string sharedKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";

		// LogName is name of the event type that is being submitted to Azure Monitor
		static string LogName = "DemoExample";

		// You can use an optional field to specify the timestamp from the data. If the time field is not specified, Azure Monitor assumes the time is the message ingestion time
		static string TimeStampField = "";

		static void Main()
		{
			// Create a hash for the API signature
			var datestring = DateTime.UtcNow.ToString("r");
			var jsonBytes = Encoding.UTF8.GetBytes(json);
			string stringToHash = "POST\n" + jsonBytes.Length + "\napplication/json\n" + "x-ms-date:" + datestring + "\n/api/logs";
			string hashedString = BuildSignature(stringToHash, sharedKey);
			string signature = "SharedKey " + customerId + ":" + hashedString;

			PostData(signature, datestring, json);
		}

		// Build the API signature
		public static string BuildSignature(string message, string secret)
		{
			var encoding = new System.Text.ASCIIEncoding();
			byte[] keyByte = Convert.FromBase64String(secret);
			byte[] messageBytes = encoding.GetBytes(message);
			using (var hmacsha256 = new HMACSHA256(keyByte))
			{
				byte[] hash = hmacsha256.ComputeHash(messageBytes);
				return Convert.ToBase64String(hash);
			}
		}

		// Send a request to the POST API endpoint
		public static void PostData(string signature, string date, string json)
		{
			try
			{
				string url = "https://" + customerId + ".ods.opinsights.azure.com/api/logs?api-version=2016-04-01";

				System.Net.Http.HttpClient client = new System.Net.Http.HttpClient();
				client.DefaultRequestHeaders.Add("Accept", "application/json");
				client.DefaultRequestHeaders.Add("Log-Type", LogName);
				client.DefaultRequestHeaders.Add("Authorization", signature);
				client.DefaultRequestHeaders.Add("x-ms-date", date);
				client.DefaultRequestHeaders.Add("time-generated-field", TimeStampField);

				// If charset=utf-8 is part of the content-type header, the API call may return forbidden.
				System.Net.Http.HttpContent httpContent = new StringContent(json, Encoding.UTF8);
				httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
				Task<System.Net.Http.HttpResponseMessage> response = client.PostAsync(new Uri(url), httpContent);

				System.Net.Http.HttpContent responseContent = response.Result.Content;
				string result = responseContent.ReadAsStringAsync().Result;
				Console.WriteLine("Return Result: " + result);
			}
			catch (Exception excep)
			{
				Console.WriteLine("API Post Exception: " + excep.Message);
			}
		}
	}
}

Python

Poznámka:

Pokud používáte Python 2, možná budete muset změnit řádek: bytes_to_hash = bytes(string_to_hash, encoding="utf-8") na bytes_to_hash = bytes(string_to_hash).encode("utf-8")

import json
import requests
import datetime
import hashlib
import hmac
import base64

# Update the customer ID to your Log Analytics workspace ID
customer_id = 'xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'

# For the shared key, use either the primary or the secondary Connected Sources client authentication key   
shared_key = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"

# The log type is the name of the event that is being submitted
log_type = 'WebMonitorTest'

# An example JSON web monitor object
json_data = [{
   "slot_ID": 12345,
    "ID": "5cdad72f-c848-4df0-8aaa-ffe033e75d57",
    "availability_Value": 100,
    "performance_Value": 6.954,
    "measurement_Name": "last_one_hour",
    "duration": 3600,
    "warning_Threshold": 0,
    "critical_Threshold": 0,
    "IsActive": "true"
},
{   
    "slot_ID": 67890,
    "ID": "b6bee458-fb65-492e-996d-61c4d7fbb942",
    "availability_Value": 100,
    "performance_Value": 3.379,
    "measurement_Name": "last_one_hour",
    "duration": 3600,
    "warning_Threshold": 0,
    "critical_Threshold": 0,
    "IsActive": "false"
}]
body = json.dumps(json_data)

#####################
######Functions######  
#####################

# Build the API signature
def build_signature(customer_id, shared_key, date, content_length, method, content_type, resource):
    x_headers = 'x-ms-date:' + date
    string_to_hash = method + "\n" + str(content_length) + "\n" + content_type + "\n" + x_headers + "\n" + resource
    bytes_to_hash = bytes(string_to_hash, encoding="utf-8")  
    decoded_key = base64.b64decode(shared_key)
    encoded_hash = base64.b64encode(hmac.new(decoded_key, bytes_to_hash, digestmod=hashlib.sha256).digest()).decode()
    authorization = "SharedKey {}:{}".format(customer_id,encoded_hash)
    return authorization

# Build and send a request to the POST API
def post_data(customer_id, shared_key, body, log_type):
    method = 'POST'
    content_type = 'application/json'
    resource = '/api/logs'
    rfc1123date = datetime.datetime.utcnow().strftime('%a, %d %b %Y %H:%M:%S GMT')
    content_length = len(body)
    signature = build_signature(customer_id, shared_key, rfc1123date, content_length, method, content_type, resource)
    uri = 'https://' + customer_id + '.ods.opinsights.azure.com' + resource + '?api-version=2016-04-01'

    headers = {
        'content-type': content_type,
        'Authorization': signature,
        'Log-Type': log_type,
        'x-ms-date': rfc1123date
    }

    response = requests.post(uri,data=body, headers=headers)
    if (response.status_code >= 200 and response.status_code <= 299):
        print('Accepted')
    else:
        print("Response code: {}".format(response.status_code))

post_data(customer_id, shared_key, body, log_type)

Java

import org.apache.http.HttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.springframework.http.MediaType;

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.text.SimpleDateFormat;
import java.util.Base64;
import java.util.Calendar;
import java.util.TimeZone;
import java.util.Locale;

import static org.springframework.http.HttpHeaders.CONTENT_TYPE;

public class ApiExample {

  private static final String workspaceId = "xxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx";
  private static final String sharedKey = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
  private static final String logName = "DemoExample";
  /*
  You can use an optional field to specify the timestamp from the data. If the time field is not specified,
  Azure Monitor assumes the time is the message ingestion time
   */
  private static final String timestamp = "";
  private static final String json = "{\"name\": \"test\",\n" + "  \"id\": 1\n" + "}";
  private static final String RFC_1123_DATE = "EEE, dd MMM yyyy HH:mm:ss z";

  public static void main(String[] args) throws IOException, NoSuchAlgorithmException, InvalidKeyException {
    String dateString = getServerTime();
    String httpMethod = "POST";
    String contentType = "application/json";
    String xmsDate = "x-ms-date:" + dateString;
    String resource = "/api/logs";
    String stringToHash = String
        .join("\n", httpMethod, String.valueOf(json.getBytes(StandardCharsets.UTF_8).length), contentType,
            xmsDate , resource);
    String hashedString = getHMAC256(stringToHash, sharedKey);
    String signature = "SharedKey " + workspaceId + ":" + hashedString;

    postData(signature, dateString, json);
  }

  private static String getServerTime() {
    Calendar calendar = Calendar.getInstance();
    SimpleDateFormat dateFormat = new SimpleDateFormat(RFC_1123_DATE, Locale.US);
    dateFormat.setTimeZone(TimeZone.getTimeZone("GMT"));
    return dateFormat.format(calendar.getTime());
  }

  private static void postData(String signature, String dateString, String json) throws IOException {
    String url = "https://" + workspaceId + ".ods.opinsights.azure.com/api/logs?api-version=2016-04-01";
    HttpPost httpPost = new HttpPost(url);
    httpPost.setHeader("Authorization", signature);
    httpPost.setHeader(CONTENT_TYPE, MediaType.APPLICATION_JSON_VALUE);
    httpPost.setHeader("Log-Type", logName);
    httpPost.setHeader("x-ms-date", dateString);
    httpPost.setHeader("time-generated-field", timestamp);
    httpPost.setEntity(new StringEntity(json));
    try(CloseableHttpClient httpClient = HttpClients.createDefault()){
      HttpResponse response = httpClient.execute(httpPost);
      int statusCode = response.getStatusLine().getStatusCode();
      System.out.println("Status code: " + statusCode);
    }
  }

  private static String getHMAC256(String input, String key) throws InvalidKeyException, NoSuchAlgorithmException {
    String hash;
    Mac sha256HMAC = Mac.getInstance("HmacSHA256");
    Base64.Decoder decoder = Base64.getDecoder();
    SecretKeySpec secretKey = new SecretKeySpec(decoder.decode(key.getBytes(StandardCharsets.UTF_8)), "HmacSHA256");
    sha256HMAC.init(secretKey);
    Base64.Encoder encoder = Base64.getEncoder();
    hash = new String(encoder.encode(sha256HMAC.doFinal(input.getBytes(StandardCharsets.UTF_8))));
    return hash;
  }

}

Alternativy a důležité informace

I když by rozhraní API kolektoru dat mělo pokrýt většinu vašich potřeb při shromažďování bezplatných dat do protokolů Azure, můžete vyžadovat alternativní přístup k překonání některých omezení rozhraní API. Možnosti, včetně důležitých aspektů, jsou uvedené v následující tabulce:

Alternativa	Popis	Nejvhodnější pro
Vlastní události: Příjem dat založený na nativní sadě SDK v Application Insights	Application Insights, obvykle instrumentované prostřednictvím sady SDK v rámci vaší aplikace, umožňuje odesílat vlastní data prostřednictvím vlastních událostí.	Data vygenerovaná v rámci vaší aplikace, ale nevybíraná sadou SDK prostřednictvím jednoho z výchozích datových typů (požadavky, závislosti, výjimky atd.). Data, která nejčastěji korelují s jinými aplikačními daty v Application Insights
Rozhraní API kolektoru dat v protokolech služby Azure Monitor	Rozhraní API kolektoru dat v protokolech služby Azure Monitor je zcela otevřený způsob, jak ingestovat data. Sem se dají odeslat všechna data formátovaná v objektu JSON. Po odeslání se zpracuje a zpřístupní v protokolech monitorování, aby bylo možné korelovat s dalšími daty v protokolech monitorování nebo s jinými daty Application Insights. Je poměrně snadné nahrát data jako soubory do objektu blob služby Azure Blob Storage, kde se soubory zpracují a pak nahrají do Log Analytics. Ukázkovou implementaci najdete v tématu Vytvoření datového kanálu pomocí rozhraní API kolektoru dat.	Data, která nejsou nutně generována v rámci aplikace instrumentované v Rámci Application Insights. Mezi příklady patří vyhledávací tabulky a tabulky faktů, referenční data, předem agregované statistiky atd. Data, která budou křížově odkazována na jiná data služby Azure Monitor (Application Insights, další datové typy protokolů monitorování, Defender for Cloud, Přehledy kontejnerů a virtuální počítače atd.).
Azure Data Explorer	Azure Data Explorer, nyní obecně dostupný pro veřejnost, je datová platforma, která využívá Application Insights Analytics a protokoly služby Azure Monitor. Díky použití datové platformy v nezpracované podobě máte úplnou flexibilitu (ale vyžaduje režii při správě) clusteru (řízení přístupu na základě role Kubernetes (RBAC), rychlost uchovávání, schéma atd.). Azure Data Explorer nabízí řadu možností příjmu dat, včetně souborů CSV, TSV a JSON .	Data, která nebudou korelována s žádnými dalšími daty v rámci Application Insights nebo monitorování protokolů. Data, která vyžadují pokročilé možnosti příjmu dat nebo zpracování, které nejsou dnes k dispozici v protokolech služby Azure Monitor.

Další kroky

• K načtení dat z pracovního prostoru služby Log Analytics použijte rozhraní API pro prohledávání protokolů.

• Přečtěte si další informace o tom, jak vytvořit datový kanál pomocí rozhraní API kolektoru dat pomocí pracovního postupu Logic Apps ve službě Azure Monitor.