Odesílání dat protokolů do služby Azure Monitor s využitím rozhraní API kolektoru dat HTTP (Preview)

Tento článek ukazuje, jak pomocí rozhraní API kolektoru dat HTTP odesílat data protokolů do služby Azure Monitor z klienta rozhraní REST API. Popisuje, jak formátovat data shromážděná vaším skriptem nebo aplikací, zahrnout je do požadavku a požádat o autorizaci 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 ve verzi Public Preview.

Koncepty

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

Všechna data v pracovním prostoru 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ů v JavaScript Object Notation (JSON). 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.

Snímek obrazovky znázorňující přehled kolektoru dat HTTP

Vytvoření požadavku

Pokud chcete použít rozhraní API kolektoru dat HTTP, vytvoříte požadavek POST, který obsahuje data pro odeslání ve formátu JSON. Následující tři tabulky uvádějí atributy, které jsou pro každý požadavek povinné. Každý atribut podrobněji popisujeme později 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.

Hlavičky požadavku

Hlavička Description
Autorizace Autorizační podpis. Později v článku si můžete přečíst, jak vytvořit hlavičku HMAC-SHA256.
Log-Type Zadejte typ záznamu odesílaných dat. Může obsahovat jenom 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 7234.
x-ms-AzureResourceId ID prostředku Azure, ke kterému by měla být data přidružená. Naplní _ResourceId vlastnost a umožní zahrnutí dat do dotazů kontextu prostředků . Pokud toto pole není zadané, nebudou data zahrnuta do dotazů kontextových prostředků.
pole generované časem Název pole v datech, která obsahují časové razítko datové položky. 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. Poznámka: Hodnota vygenerovaná časem nesmí být starší než 2 dny před přijatým časem nebo se řádek zahodí.

Autorizace

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

Tady je formát hlavičky autorizace:

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 k 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 kódování UTF-8 a pak zakódujte výsledek jako Base64. Použijte tento formát:

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

Ukázky v dalších částech obsahují ukázkový 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 názvem vlastnosti a páry hodnot 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 dávkot více záznamů pomocí následujícího formátu. Všechny záznamy musí být stejný typ 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ů vytvořených 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 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 názvu, který zadáte, aby se odlišil 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 těmi, které jsou dodávány v aktuálních nebo budoucích řešeních Microsoftu.

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

Datový typ vlastnosti Přípona
Řetězec _s
Logická hodnota _b
dvojité _d
Datum a čas _t
IDENTIFIKÁTOR GUID (uložený jako řetězec) _g

Poznámka

Řetězcové hodnoty, které se zobrazují 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: "8145d82-13a7-44ad-859c-36f31a84f6dd" a "8145d8213a744ad"859c36f31a84f6dd" jsou uloženy jako 8145d82-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 datový typ vlastnosti v novém záznamu neodpovídá a nedá se převést na existující typ nebo pokud záznam obsahuje vlastnost, která neexistuje, Azure Monitor vytvoří novou vlastnost, která má příslušnou příponu.

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

Snímek obrazovky s ukázkovým záznamem 1

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

Snímek obrazovky s ukázkovým záznamem 2

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

Snímek obrazovky s ukázkovým záznamem 3

Pokud pak odešlete následující položku, před vytvořením typu záznamu vytvoří Azure Monitor 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 naformátovaná jako řetězec:

Snímek obrazovky s ukázkovým záznamem 4

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:

  • nájemce
  • TimeGenerated
  • RawData

Omezení dat

Data publikovaná 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 Jedná se o limit velikosti pro jeden příspěvek. Pokud data z jednoho příspěvku překročí 30 MB, měli byste je rozdělit na menší bloky dat 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 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 žádost byla přijata 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 Description
200 OK Požadavek byl úspěšně přijat.
400 Chybný požadavek NeaktivníCustomer Pracovní prostor byl uzavř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. Text 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 číselné znaky.
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 Požadovaný typ protokolu hodnot nebyl zadán.
400 Chybný požadavek Nepodporovaný typContentType Typ obsahu nebyl nastavený na application/json.
403 Forbidden Neplatná ověřování Služba 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 Služba není k dispozici ServiceUnavailable Služba aktuálně není k dispozici pro příjem požadavků. Zkuste prosím žádost zopakovat.

Dotazování dat

Pokud chcete dotazovat data odeslaná rozhraním API kolektoru dat HTTP služby Azure Monitor, vyhledejte záznamy, jejichž typ se rovná 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 dalších částech najdete 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 hlavičku autorizace následujícím způsobem:

  1. V Azure Portal vyhledejte pracovní prostor Služby Log Analytics.
  2. Vyberte správu agentů.
  3. Napravo od ID pracovního prostoru vyberte ikonu Kopírovat a vložte ID jako hodnotu proměnné ID zákazníka .
  4. Napravo od primárního klíče vyberte ikonu Kopírovat a vložte ID jako hodnotu proměnné sdíleného klíče .

Alternativně můžete změnit proměnné pro typ protokolu a data JSON.

Ukázka PowerShellu

# 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  

Ukázka v jazyce 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);

				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);
			}
		}
	}
}

Ukázka Pythonu

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") k 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)

Ukázka Javy


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 aspekty

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 vyřešení některých omezení rozhraní API. Vaše možnosti, včetně důležitých aspektů, jsou uvedené v následující tabulce:

Alternativa Description 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 generovaná 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 daty aplikací ve službě 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. Všechna data formátovaná v objektu JSON je možné odeslat sem. Po odeslání se zpracuje a zpřístupní v protokolech monitorování, aby bylo možné korelovat s jinými daty v protokolech monitorování nebo s jinými daty Application Insights.

Je poměrně snadné nahrát data jako soubory do Azure Blob Storage objektu blob, 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, která je instrumentovaná v 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, jiné datové typy protokolů monitorování, Defender for Cloud, Přehledy kontejnerů a virtuální počítače atd.).
Azure Data Explorer Azure Data Explorer, která je teď obecně dostupná pro veřejnost, je datová platforma, která využívá protokoly Application Insights Analytics a Azure Monitoru. Pomocí datové platformy v nezpracované podobě máte úplnou flexibilitu (ale vyžadujete režii správy) nad clusterem (ří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 jinými daty v rámci protokolů Application Insights nebo Monitorování.
  • 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